Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/ZSI/wstools/TimeoutSocket.pyo

Python Compiled Bytecode | 2008-10-13 | 5KB | 223 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

ident = '$Id: TimeoutSocket.py 237 2003-05-20 21:10:14Z warnes $'
import string
import socket
import select
import errno
WSAEINVAL = getattr(errno, 'WSAEINVAL', 10022)

class TimeoutSocket:

    def __init__(self, timeout = 20, sock = None):
        self.timeout = float(timeout)
        self.inbuf = ''
        if sock is None:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        self.sock = sock
        self.sock.setblocking(0)
        self._rbuf = ''
        self._wbuf = ''


    def __getattr__(self, name):
        return getattr(self.sock, name)


    def connect(self, *addr):
        timeout = self.timeout
        sock = self.sock

        try:
            sock.setblocking(0)
            apply(sock.connect, addr)
            sock.setblocking(timeout != 0)
            return 1
        except socket.error:
            why = None
            if not timeout:
                raise

            sock.setblocking(1)
            if len(why.args) == 1:
                code = 0
            else:
                (code, why) = why
            if code not in (errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK):
                raise

            (r, w, e) = select.select([], [
                sock], [], timeout)
            if w:

                try:
                    apply(sock.connect, addr)
                    return 1
                except socket.error:
                    why = None
                    if len(why.args) == 1:
                        code = 0
                    else:
                        (code, why) = why
                    if code in (errno.EISCONN, WSAEINVAL):
                        return 1

                    raise
                except:
                    None<EXCEPTION MATCH>socket.error


            None<EXCEPTION MATCH>socket.error

        raise TimeoutError('socket connect() timeout.')


    def send(self, data, flags = 0):
        total = len(data)
        next = 0
        while None:
            (r, w, e) = select.select([], [
                self.sock], [], self.timeout)
            if w:
                buff = data[next:next + 8192]
                sent = self.sock.send(buff, flags)
                next = next + sent
                if next == total:
                    return total
                    continue
                continue

            raise TimeoutError('socket send() timeout.')
            continue
            return None


    def recv(self, amt, flags = 0):
        if select.select([
            self.sock], [], [], self.timeout)[0]:
            return self.sock.recv(amt, flags)

        raise TimeoutError('socket recv() timeout.')

    buffsize = 4096
    handles = 1

    def makefile(self, mode = 'r', buffsize = -1):
        self.handles = self.handles + 1
        self.mode = mode
        return self


    def close(self):
        self.handles = self.handles - 1
        if self.handles == 0 and self.sock.fileno() >= 0:
            self.sock.close()



    def read(self, n = -1):
        if not isinstance(n, type(1)):
            n = -1

        if n >= 0:
            k = len(self._rbuf)
            if n <= k:
                data = self._rbuf[:n]
                self._rbuf = self._rbuf[n:]
                return data

            n = n - k
            L = [
                self._rbuf]
            self._rbuf = ''
            while n > 0:
                new = self.recv(max(n, self.buffsize))
                if not new:
                    break

                k = len(new)
                if k > n:
                    L.append(new[:n])
                    self._rbuf = new[n:]
                    break

                L.append(new)
                n = n - k
            return ''.join(L)

        k = max(4096, self.buffsize)
        L = [
            self._rbuf]
        self._rbuf = ''
        while None:
            new = self.recv(k)
            if not new:
                break

            k = min(k * 2, 1048576)
            continue
            return ''.join(L)


    def readline(self, limit = -1):
        data = ''
        i = self._rbuf.find('\n')
        while i < 0 and not None if limit < limit else limit <= len(self._rbuf):
            new = self.recv(self.buffsize)
            if not new:
                break

            i = new.find('\n')
            if i >= 0:
                i = i + len(self._rbuf)

            self._rbuf = self._rbuf + new
        if i < 0:
            i = len(self._rbuf)
        else:
            i = i + 1
        if limit <= limit:
            pass
        elif limit < len(self._rbuf):
            i = limit

        data = self._rbuf[:i]
        self._rbuf = self._rbuf[i:]
        return data


    def readlines(self, sizehint = 0):
        total = 0
        list = []
        while None:
            line = self.readline()
            if not line:
                break

            total += len(line)
            if sizehint and total >= sizehint:
                break
                continue
            continue
            return list


    def writelines(self, list):
        self.send(''.join(list))


    def write(self, data):
        self.send(data)


    def flush(self):
        pass



class TimeoutError(Exception):
    pass